home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / vol_100 / 118_01 / args.bds < prev    next >
Encoding:
Text File  |  1980-07-08  |  4.0 KB  |  255 lines
  1. /* Command line handling routines for Software Tools
  2.  * source:  args.bds
  3.  * version: August 23, 1981
  4.  */
  5.  
  6. #include tools.h
  7.  
  8. /* routines on this file:
  9.  
  10.     initst        endst
  11.     getarg        delarg
  12.     $ insub        $ outsub    $ errsub
  13. */
  14.     
  15.  
  16. /* make BDS calls more visible */
  17.  
  18. #define BDS_exit  _exit
  19.  
  20.  
  21. /* test routine for initst(), and command handlers */
  22.  
  23. main(argc, argv)
  24. int argc;
  25. char **argv;
  26. {
  27.     initst(argc, argv);
  28.     echo();
  29.     endst();
  30. }
  31.  
  32. echo()
  33. {
  34.     int i;
  35.     int unit;
  36.     char *p;
  37.  
  38.     printf("Test of initst()\n");
  39.     for (i = 1; (p = getarg(i)) != NULL; i++) {
  40.         unit = open(p,READ);
  41.         printf("file %s is unit = %d\n",p,unit);
  42.     }
  43.     for (i = 0; i < SYS_STD + MAXOFILES; i++) {
  44.     if ( sys_bufp [i] != ERR ||
  45.          sys_spec [i] != ERR ||
  46.          sys_bufn [i] != ERR
  47.        ) {
  48.         printf("sys_bufp [%d] = %x ",i,sys_bufp [i]);
  49.         printf("sys_bufn [%d] = %3d ",i,sys_bufn [i]);
  50.         printf("sys_spec [%d] = %3d\n",i,sys_spec [i]);
  51.     }
  52.     }
  53.     printf("End of test\n");
  54. }
  55.  
  56. /*    delarg - delete argument n from the command line */
  57.  
  58. delarg (n)
  59. int n;
  60. {
  61.  
  62.     /*  include common /args/ */
  63.     int i;
  64.  
  65.     /* check for valid argument number */
  66.     if (n < 0 || n > sys_narg) {
  67.         return;
  68.     }
  69.  
  70.     /* move pointers down */
  71.     for (i = n; i < sys_narg; i++) {
  72.         sys_args [i] = sys_args [i + 1];
  73.     }
  74.  
  75.     sys_narg--;
  76. }
  77.  
  78. /*    endst - close all files and terminate the program */
  79.  
  80. endst()
  81. {
  82.     int i;
  83.  
  84.     for (i = 0; i < MAXOFILES + SYS_STD; i++) {
  85.         close (i);
  86.     }
  87.     BDS_exit();
  88. }
  89.  
  90. /*    errsub - see if argument is ERROUT substitution
  91.  *               abort if we can not open the file
  92.  */
  93.  
  94. BOOL errsub (arg)
  95. char arg[];
  96. {
  97.  
  98.     int access;
  99.  
  100.     if ( arg [0] == '?' &&
  101.          arg [1] != '?' &&
  102.          arg [1] != EOS
  103.        ) {
  104.         arg++;
  105.         access = WRITE;
  106.     }
  107.     else if ( arg [0] == '?' &&
  108.               arg [1] == '?' &&
  109.               arg [2] != EOS
  110.             ) {
  111.         arg++;
  112.         arg++;
  113.         access = APPEND;
  114.     }
  115.     else {
  116.         return(NO);
  117.     }
  118.  
  119.     if (_assign(ERROUT, arg, access) == NO) {
  120.         /* abort -- no place for error message */
  121.         endst();
  122.     }
  123.     return(YES);
  124. }
  125.  
  126. /*    getarg - return pointer to n'th arg.
  127.  *         this is a change from software tools.
  128.  */
  129.  
  130. POINTER getarg (n)
  131. int n;
  132. {
  133.     if (n < 1 || n > sys_narg) {
  134.         return(EOS);
  135.     }
  136.     else {
  137.         return(sys_args [n]);
  138.     }
  139. }
  140.  
  141.  
  142. /*    initst - initialize software tools programs */
  143.  
  144. initst(argc, argv)
  145. int argc;
  146. char **argv;
  147. {
  148.  
  149.     int i;
  150.     POINTER arg;
  151.  
  152.     /* initialize system date */
  153.  
  154.     sys_date [0] = EOS;
  155.  
  156.     /* initialize system storage management */
  157.  
  158.     /* dsinit(); */
  159.     _allocp = NULL;
  160.  
  161.     /* initialize system argument area */
  162.  
  163.     sys_narg = argc - 1;
  164.  
  165.     sys_args [0] = NULL;    
  166.     for (i = 1; i < argc; i++) {
  167.         sys_args [i] = argv [i];
  168.     }
  169.  
  170.     /* close all disk files */
  171.  
  172.     for (i = 0; i < SYS_STD + MAXOFILES; i++) {
  173.         sys_bufp [i] = ERR;
  174.         sys_bufn [i] = ERR;
  175.         sys_spec [i] = ERR;
  176.     }
  177.  
  178.     /* open the standard units */
  179.  
  180.     sys_spec [STDIN]    = SYS_TERM;
  181.     sys_spec [STDOUT]   = SYS_TERM;
  182.     sys_spec [ERROUT]   = SYS_TERM;
  183.     sys_spec [SYS_TERM] = SYS_TERM;
  184.     sys_spec [SYS_PRT]  = SYS_PRT;
  185.  
  186.     /*  pick up file substitutions for standard files */
  187.     for (i = 1; (arg = getarg(i)) != NULL; ) {
  188.  
  189.         if ( insub  (arg) == YES ||
  190.              outsub (arg) == YES ||
  191.              errsub (arg) == YES
  192.            ) {
  193.             delarg(i);
  194.         }
  195.         else {
  196.             i++;
  197.         }
  198.     }
  199. }
  200.  
  201. /*    insub - check for STDIN substitution */
  202.  
  203. BOOL insub (arg)
  204. char arg [];
  205. {
  206.     if (arg [0] == '<' && arg [1] != EOS) {
  207.         arg++;
  208.     }
  209.     else {
  210.         return(NO);
  211.     }
  212.  
  213.     if (_assign(STDIN, arg, READ) == NO) {
  214.         cant (arg);
  215.         return(NO);
  216.     }
  217.     return(YES);
  218. }
  219.  
  220. /*    outsub - check for STDOUT substitution */
  221.  
  222. BOOL outsub (arg)
  223. char arg[];
  224. {
  225.  
  226.     int access;
  227.  
  228.     if ( arg [0] == '>' &&
  229.          arg [1] != '>' &&
  230.          arg [1] != EOS
  231.        ) {
  232.         arg++;
  233.         access = WRITE;
  234.     }
  235.  
  236.     else if ( arg [0] == '>' &&
  237.               arg [1] == '>' &&
  238.               arg [2] != EOS
  239.             ) {
  240.         arg++;
  241.         arg++;
  242.         access = APPEND;
  243.     }
  244.     else {
  245.         return(NO);
  246.     }
  247.  
  248.     if (_assign(STDOUT, arg, access) == NO) {
  249.         cant (arg);
  250.         return(NO);
  251.     }
  252.     return(YES);
  253. }
  254.  
  255.